
1.创建
    对象字面量：var obj={

    }
    构造函数 var obj= new Object();

2.访问
    . 
    []

3.删除
    delete 属性访问表达式
    delete obj.name

4.检测属性
    in:检测当前属性是不是该对象的自有属性或者继承属性
    hasOwnProperty:检测属性是否是当前对象的自有属性

5.对象序列化
    JSON.parse：把json字符串转化为对象
    JSON.stringify:把对象序列转化成json字符串

6.构造函数和原型对象
    每一个构造函数都有一个原型对象（prototype）
    每一个原型对象都会有constructor

    静态方法/属性
        Object.assign(a,b)
        Object.keys()
        Object.values()
        Object.defineProperty(obj,"key",{
            //属性描述符
                value:""
                writable:true/false
                enumerable:true/false
                configurable:true/false
            //存取操作符
                set:function(){}
                get:function(){}
        })
        
    非静态方法/属性
    constructor:1.Object.prototype.constructor
                2.new Object().constructor
                function的父级 function Function(){}
                               Function.prototype.valueOf{}

        propertyIsEnumerable:是否可遍历

7.函数：就是一个特殊的对象

        普通函数：
            函数名（） ——>function say(){}  say()
        构造函数：
            new object()

    1.创建
        函数自面量
            var say=function(){}
        函数声明
            function say(){}
        匿名函数
            (function(){})

        ##解析顺序：优先解析函数的声明，在解析使用var的操作符声明的变量

    2.调用
        函数名()
        new 函数名()
    
    3.参数
        实际参数
        形式参数
            function say(形式参数){

            }
            say(实际参数);
        ##形式参数可以和实际参数个数不一致，类型随意

    4.内部属性
            arguments:用来保存当前拥有arguments对象的函数的实际参数列表（类数组对象）
                [1,2,3,3]:数组下标从0开始
                arguments.length：数组的长度->参数的个数
                arguments.callee:从函数内部指向拥有arguments的函数（测试阶乘相加）

            this：当前函数赖以生存的环境变量
                this何时确定？当拥有当前this的函数被调用时确定
                this指向谁？当前拥有this的函数被谁调用就指向谁
    
    5.作为值的函数/作为返回值的函数

        1.作为值的函数    
            function say(){  //1001
                console.log(this);//windows
            }
            function getSay(fn){  //1001
                fn()  //windows
            }

            getSay(say)

        2.作为返回值的函数
            function say() {
                return function () {
                    console.log("hello")
                }
            }

            var a = say();
            a();
            
    6.函数的属性和方法
            
        say.length 

        say.apply(this,[实参列表])
        say.call(this,实参列表):修改了函数内部的this值的指向
        


3.数组
        特点：1.数组长度可以修改
             2.数组元素类型可以任意

             length：可以获取数组长度，也可以修改数组长度 arr.length 
        1.创建
            1.数组字面量 
                var arr = [1,2,null,true];
            2.构造函数
                var arr = new Array();构建空数组
                var arr = new Array(10);//当参数个数为1个并且数据类型为number时
                表示创造该长度的数组
                var arr = new Array(2,3,true,null);//当参数个数超过一个的时候
                创建包含参数项的数组


                function Array(){
                    if(arguments==0){
                        //构建空数组
                    }
                    else if(arguments==1&& typeof (arguments[0]=='number')){
                        //当参数个数为1个并且数据类型为number时表示创造该长度的数组
                    }else{
                        //当参数个数超过一个的时候创建包含参数项的数组
                    }
                }
                
                new Array();

        2.访问
            arr[index]: 
                index:数组下标/索引——>从0开始
                arr[1]:数组中第二个数组元素的属性值
            var arr = [];
            arr.length=5;将arr数组元素个数从0变成5

            arr=[1,2,3,4,5]
            arr.length=3//删除两个
        3.检查
               Array.isArray(a)：返回当前参数是否为参数，如果是返回true(静态方法)
               Array.from():将类数组对象（必须有length属性，属性名一定要是number类型或者字符串型的number）转换为数组
               Array.of():将参数当作数组元素添加到数组中
                
        4.转换
                将数组转换为字符串(非)
                toString()
                    Array.toString
                join()
        5.方法（参数和返回值）
                1.添加或者删除数组元素
                    1.栈方法
                        arr.pop():
                            删除一个数组元素 无参数 返回值是删除的最后一个数
                        arr.push()
                            添加一个数组元素 参数是想要添加的数组元素 返回值是添加后的数组长度
                    2.队列方法
                        arr.shift()
                                删除数组元素  无参数 返回值删除的数组元素
                        arr.unshift()
                                添加数组元素 参数是想要添加的数组元素 返回值是添加后的数组长度

                2.排序
                        1.reverse():反转 无参数 返回值是反转后的数组
                        ——是直接在原数组上进行翻转的
                        2.sort()
                            参数：无参数时调用数组元素的toString进行比较
                                  回调函数 返回值为正数，代表将a向后排
                                  function（a,b）{
                                      if(a>b){
                                          return 1
                                      }else if (a< b) {
                                            return -1
                                      }else{
                                          return 0
                                      }
                                  }

                作业： var arr=[{
                    name:"a",
                    age:"10",
                    sarlary:1000
                },{
                    name:"b",
                    age:"39",
                    sarlary:1500
                },{
                    name:"f",
                    age:"23",
                    sarlary:600
                },{
                    name:"d",
                    age:"50",
                    sarlary:800
                }]

                //创建一个比较函数 只写一次；
                age/name/sarlary